#include <stdio.h>
#include <stdlib.h>

/* 链式队列及其操作 */
typedef enum {false, true} bool;
typedef int QElemSet;
#define NIL -1

typedef struct QueueNode *Position; /* 指针即结点位置 */
struct QueueNode {
    QElemSet data; /* 存储数据 */
    Position next; /* 链式队列中下一个元素的位置 */
};
typedef struct QueueHeadNode *Queue;
struct QueueHeadNode {
    int size; /* 链式队列中当前元素个数 */
    Position front; /* 链式队列的队首指针，初始化为NULL */
    Position rear; /* 链式队列的队尾指针，初始化为NULL */
};

void InitQueue(Queue queue);
bool IsEmpty(Queue queue);
void EnQueue(Queue queue, QElemSet x);
QElemSet GetFront(Queue queue);
void DeQueue(Queue queue);
QElemSet GetRear(Queue queue); /* 查看队尾 */
void DestroyQueue(Queue queue);
/* 链式队列及其操作 结束 */

bool TrainCarriageScheduling(QElemSet in_track[], Queue out_track, int n,
                             int k);

int main(void) {
    int i, n, k;
    QElemSet *in_track;
    Queue out_track;

    scanf("%d %d", &n, &k);
    in_track = (QElemSet *)malloc(sizeof(QElemSet) * n);
    out_track = (Queue)malloc(sizeof(struct QueueHeadNode));
    for (i = 0; i < n; i++) {
        scanf("%d", &in_track[i]);
    }
    if (TrainCarriageScheduling(in_track, out_track, n, k) == true) {
        for (i = 0; i < n; i++) {
            printf("%d\n", GetFront(out_track));
            DeQueue(out_track);
        }
    }
    DestroyQueue(out_track);
    return 0;
}

void InitQueue(Queue queue) {
    /* 初始化一个空的链式队列 */
    queue->size = 0;
    queue->front = NULL;
    queue->rear = NULL;
}

bool IsEmpty(Queue queue) {
    /* 判断队列是否为空 */
    if (queue->size == 0)
        return true;
    else
        return false;
}

void EnQueue(Queue queue, QElemSet x) {
    Position new_node;

    new_node = (Position)malloc(sizeof(struct QueueNode));
    new_node->data = x;
    new_node->next = NULL;
    if (IsEmpty(queue)) { /* 特殊处理插入空队列的情况 */
        queue->rear = new_node;
        queue->front = new_node;
    } else {
        queue->rear->next = new_node;
        queue->rear = queue->rear->next;
    }
    queue->size++;
}

QElemSet GetFront(Queue queue) {
    if (IsEmpty(queue)) {
        /*printf("错误：队列为空。\n");*/
        return NIL;
    } else {
        return queue->front->data;
    }
}

void DeQueue(Queue queue) {
    Position temp;

    if (IsEmpty(queue)) {
        /*printf("错误：队列为空。\n");*/
    } else {
        temp = queue->front;
        queue->front = queue->front->next;
        free(temp);
        queue->size--;
        if (queue->front == NULL) {
            /* 特殊处理删除后变为空的队列 */
            queue->rear = NULL;
        }
    }
}

QElemSet GetRear(Queue queue) {
    if (IsEmpty(queue)) {
        /*printf("错误：队列为空。\n");*/
        return NIL;
    } else {
        return queue->rear->data;
    }
}

void DestroyQueue(Queue queue) {
    while (IsEmpty(queue) == false) {
        DeQueue(queue);
    }
    free(queue);
}

/* 算法3-15：车厢重排 TrainCarriageScheduling(in_track, out_track, n, k) */
bool TrainCarriageScheduling(QElemSet in_track[], Queue out_track, int n,
                             int k) {
    Queue *buffer;
    int i, j, next_out, front_crg, rear_crg, max_buffer;
    QElemSet max_rear;
    bool ret;

    ret = true;
    /* 创建k个缓冲队列 */
    buffer = (Queue *)malloc(sizeof(Queue) * k);
    for (i = 0; i < k; i++) {
        buffer[i] = (Queue)malloc(sizeof(struct QueueHeadNode));
        InitQueue(buffer[i]);
    }
    InitQueue(out_track); /* 初始化出轨队列 */
    next_out = 1; /* 下一个应该出轨的车厢编号 */
    for (i = 0; i < n; i++) {
        if (in_track[i] == next_out) {/* 当前车厢正好应该出 */
            EnQueue(out_track, i); /* 当前车厢的原始位序入列出轨 */
            next_out++; /* 更新下一个应该出轨的车厢编号 */
        } else {
            /* 从缓冲轨中找到应该进入出轨的车厢 */
            for (j = 0; j < k; j++) { /* 考察每一缓冲轨队列 */
                front_crg = GetFront(buffer[j]); /* 查看队列j的头元素 */
                if ((front_crg != NIL)
                && (in_track[front_crg] == next_out)) { /* 找到应该进入出轨的 */
                    EnQueue(out_track, front_crg); /* 该车厢的原始位序入列出轨 */
                    DeQueue(buffer[j]); /* 并从删除区删除 */
                    next_out++; /* 更新下一个应该出轨的车厢编号 */
                }
            }
            /* 将当前车厢放入缓冲区，保证其编号比队尾大 */
            max_rear = 0;
            max_buffer = -1;
            for (j = 0; j < k; j++) {
                rear_crg = GetRear(buffer[j]); /* 查看队列j的尾元素 */
                if ((rear_crg != NIL) && (in_track[i] > in_track[rear_crg])) {
                    if (in_track[rear_crg] > max_rear) { /*找比当前编号小的最大元*/
                        max_rear = in_track[rear_crg]; /* 最大队尾元素值 */
                        max_buffer = j; /* 最大队尾元素所在的队列编号 */
                    }
                }
            }
            if (max_buffer != -1) { /* 找到了则入列 */
                EnQueue(buffer[max_buffer], i);
            } else { /* 找一个空的缓冲轨入列 */
                for (j = 0; j < k; j++) {
                    if (IsEmpty(buffer[j])) {
                        break;
                    }
                }
                if (j < k) {
                    EnQueue(buffer[j], i);
                } else {
                    printf("错误：任务不可能完成。\n");
                    ret = false;
                    break;
                }
            }
        }
    }
    while (ret == true && next_out <= n) {
        for (j = 0; j < k; j++) { /* 考察每一缓冲轨队列 */
            front_crg = GetFront(buffer[j]); /* 查看队列j的头元素 */
            if ((front_crg != NIL)
            && (in_track[front_crg] == next_out)) { /* 找到应该进入出轨的 */
                EnQueue(out_track, front_crg); /* 该车厢的原始位序入列出轨 */
                DeQueue(buffer[j]); /* 并从删除区删除 */
                next_out++; /* 更新下一个应该出轨的车厢编号 */
                break;
            }
        }
    }
    for (i = 0; i < k; i++) {
        DestroyQueue(buffer[i]);
    }
    return ret;
}
/* 算法3-15 结束 */